// 安全获取环境变量的函数
const getEnvVar = (key) => {
  try {
    return import.meta.env?.[key] || (typeof process !== 'undefined' ? process.env?.[key] : undefined);
  } catch (error) {
    return undefined;
  }
};

// AI 服务配置
const AI_CONFIG = {
  // DeepSeek API (推荐 - 性能强大且价格便宜)
  DEEPSEEK: {
    enabled: false, // 设为 true 并配置 API key 后启用
    apiKey: getEnvVar('REACT_APP_DEEPSEEK_API_KEY'),
    baseURL: 'https://api.deepseek.com/v1/chat/completions',
    model: 'deepseek-chat'
  },

  // 通义千问 API (阿里云)
  QWEN: {
    enabled: false, // 设为 true 并配置 API key 后启用
    apiKey: getEnvVar('REACT_APP_QWEN_API_KEY'),
    baseURL: 'https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation',
    model: 'qwen-plus'
  },

  // 讯飞星火配置
  XUNFEI: {
    enabled: false, // 设为 true 并配置 API key 后启用
    apiKey: getEnvVar('REACT_APP_XUNFEI_API_KEY'),
    apiSecret: getEnvVar('REACT_APP_XUNFEI_API_SECRET'),
    appId: getEnvVar('REACT_APP_XUNFEI_APP_ID'),
    baseURL: 'https://spark-api.xf-yun.com/v1.1/chat'
  },

  // 百度文心一言配置
  BAIDU: {
    enabled: false, // 设为 true 并配置 API key 后启用
    apiKey: getEnvVar('REACT_APP_BAIDU_API_KEY'),
    secretKey: getEnvVar('REACT_APP_BAIDU_SECRET_KEY'),
    baseURL: 'https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions'
  },

  // 智能模拟模式（更聪明的回复）
  SMART_MOCK: {
    enabled: true, // 当前启用智能模拟模式
    delay: { min: 1200, max: 3000 } // 模拟真实AI的思考时间
  }
};

// 错误类型定义
const AI_ERRORS = {
  NETWORK_ERROR: 'NETWORK_ERROR',
  API_KEY_INVALID: 'API_KEY_INVALID',
  RATE_LIMIT: 'RATE_LIMIT',
  SERVER_ERROR: 'SERVER_ERROR',
  INVALID_REQUEST: 'INVALID_REQUEST',
  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
};

// 自定义错误类
class AIServiceError extends Error {
  constructor(message, type, code) {
    super(message);
    this.name = 'AIServiceError';
    this.type = type;
    this.code = code;
  }
}

// 智能模拟 AI 回复服务
class SmartMockAIService {
  constructor() {
    // 更智能的回复模板
    this.knowledgeBase = {
      // 学习相关
      '学习': {
        keywords: ['学习', '学业', '读书', '考试', '复习', '作业', '课业'],
        responses: [
          '学习是一个持续的过程，我建议你制定合理的学习计划。你可以：\n1. 使用"课程表"功能合理安排时间\n2. 通过"成绩查询"跟踪学习进度\n3. 关注"校内新闻"了解学术活动\n4. 参加各种学术讲座和研讨会',
          '关于学习效率，我推荐几个方法：\n• 番茄工作法：25分钟专注学习，5分钟休息\n• 制定清晰的学习目标和计划\n• 找到适合自己的学习环境\n• 及时复习，遵循遗忘曲线规律'
        ]
      },

      // 校园生活
      '校园': {
        keywords: ['校园', '学校', '大学', '宿舍', '食堂', '图书馆'],
        responses: [
          '校园生活丰富多彩！作为你的智能助手，我了解校园的方方面面：\n📚 学术资源：图书馆、实验室、学习空间\n🏠 生活设施：宿舍、食堂、超市、医务室\n🎭 文娱活动：社团、比赛、讲座、演出\n💳 便民服务：校园卡、网络、打印、快递',
          '校园生活小贴士：\n• 充分利用图书馆资源，这里不仅有书籍，还有安静的学习环境\n• 积极参加社团活动，结交志同道合的朋友\n• 关注学校官方通知，不错过重要信息\n• 合理安排作息时间，保持身心健康'
        ]
      },

      // 技术和学习工具
      '技术': {
        keywords: ['编程', '代码', '技术', '软件', '开发', '计算机', 'APP', '应用'],
        responses: [
          '很高兴看到你对技术的兴趣！作为一个AI助手，我深知技术学习的重要性：\n💻 编程语言：建议从基础语言开始，如Python、JavaScript\n🛠️ 开发工具：熟练使用IDE、版本控制工具如Git\n📱 项目实践：通过实际项目加深理解\n🌐 持续学习：关注技术发展趋势，保持学习热情',
          '技术学习建议：\n• 理论与实践相结合，多动手写代码\n• 参与开源项目，提升实战能力\n• 建立技术博客，记录学习心得\n• 加入技术社区，与同行交流学习'
        ]
      },

      // 情感支持
      '情感': {
        keywords: ['累', '压力', '焦虑', '困难', '挫折', '迷茫', '孤独', '难过'],
        responses: [
          '我理解你现在的感受，每个人都会遇到困难和挫折。记住：\n🌟 困难是成长的机会，每次克服都让你更强大\n💪 你已经走了这么远，相信自己有能力继续前进\n🤝 不要独自承担，寻求朋友、老师或专业人士的帮助\n🌈 保持积极心态，困难总会过去，美好正在路上',
          '面对压力和挫折的小建议：\n• 深呼吸，给自己一点时间和空间\n• 把大问题分解成小步骤，逐一解决\n• 适当运动，释放负面情绪\n• 与信任的人分享，获得支持和建议\n• 记住，寻求帮助是勇敢的表现，不是软弱'
        ]
      }
    };

    // 智能回复生成器
    this.smartResponses = [
      '这是一个很有深度的问题。从我的分析来看，',
      '基于我对校园服务的了解，我认为',
      '这个问题很有意思！让我从几个角度来分析：',
      '我注意到你提到的这个问题，这确实是很多同学关心的。',
      '作为你的AI助手，我很乐意为你提供专业的建议：',
      '从数据和经验来看，这种情况确实需要注意。'
    ];
  }

  async sendMessage(message) {
    // 模拟更真实的思考时间
    const delay = Math.random() * (AI_CONFIG.SMART_MOCK.delay.max - AI_CONFIG.SMART_MOCK.delay.min) + AI_CONFIG.SMART_MOCK.delay.min;
    await new Promise(resolve => setTimeout(resolve, delay));

    // 生成智能回复
    const response = this.generateSmartResponse(message);

    return {
      success: true,
      data: {
        reply: response,
        timestamp: new Date().toISOString(),
        messageId: Date.now().toString()
      }
    };
  }

  generateSmartResponse(message) {
    const lowerMessage = message.toLowerCase();

    // 智能关键词匹配
    for (const [category, data] of Object.entries(this.knowledgeBase)) {
      for (const keyword of data.keywords) {
        if (message.includes(keyword)) {
          const responses = data.responses;
          return responses[Math.floor(Math.random() * responses.length)];
        }
      }
    }

    // 问候处理
    if (/^(你好|hi|hello|嗨)/.test(lowerMessage)) {
      return '你好！我是你的AI校园助手 🤖\n\n我可以帮助你：\n• 📚 学习和课程相关问题\n• 🏫 校园生活指导\n• 💳 校园服务使用\n• 📰 获取最新资讯\n• 🤝 提供情感支持\n\n有什么我可以帮助你的吗？';
    }

    // 感谢处理
    if (/(谢谢|感谢|thank)/.test(lowerMessage)) {
      return '很高兴能帮助到你！😊 如果还有其他问题，随时都可以来问我。我会一直在这里为你提供支持和帮助。祝你学习生活愉快！';
    }

    // 询问类问题
    if (/(什么|怎么|如何|为什么|哪里|when|where|how|what|why)/.test(lowerMessage)) {
      const starters = [
        '这是一个很好的问题！',
        '让我来为你详细解答：',
        '基于我的了解，',
        '从实用角度来说，'
      ];
      const starter = starters[Math.floor(Math.random() * starters.length)];

      return `${starter}\n\n针对你的问题，我建议：\n• 首先明确你的具体需求和目标\n• 查看相关的功能模块获取详细信息\n• 如果需要人工帮助，可以联系相关部门\n• 也可以继续和我交流，我会尽力提供更具体的建议`;
    }

    // 校园服务相关
    if (/(成绩|查询|课程|新闻|校园卡|介绍)/.test(message)) {
      return '关于校园服务，我来为你详细介绍：\n\n🏫 **学校介绍** - 了解学校历史、专业设置、校园文化\n📊 **成绩查询** - 实时查看各科成绩、学分、绩点信息\n📅 **课程表** - 查看课程安排，设置提醒，合理规划时间\n📰 **校内新闻** - 获取最新校园资讯、通知公告\n💳 **校园卡服务** - 充值、挂失、使用指南等\n\n你想了解哪个具体功能呢？';
    }

    // 默认智能回复
    const randomStarter = this.smartResponses[Math.floor(Math.random() * this.smartResponses.length)];
    const suggestions = [
      '建议你可以通过相关功能模块获取更详细的信息。',
      '如果需要更具体的帮助，请告诉我你的具体需求。',
      '我会持续学习，为你提供更好的服务。',
      '有任何问题都可以随时问我，我很乐意帮助你。'
    ];
    const suggestion = suggestions[Math.floor(Math.random() * suggestions.length)];

    return `${randomStarter}${suggestion}\n\n💡 **小提示**：你可以尝试问我关于学习、校园生活、技术或任何你关心的问题，我会尽力提供有价值的建议和信息。`;
  }
}

// DeepSeek AI 服务 (推荐)
class DeepSeekAIService {
  constructor() {
    this.config = AI_CONFIG.DEEPSEEK;
  }

  async sendMessage(message) {
    try {
      const response = await fetch(this.config.baseURL, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.config.apiKey}`
        },
        body: JSON.stringify({
          model: this.config.model,
          messages: [
            {
              role: "system",
              content: "你是一个友好、专业的校园AI助手，专门帮助学生解决学习和校园生活中的问题。请用中文回答，语气要亲切自然，提供实用的建议。"
            },
            {
              role: "user",
              content: message
            }
          ],
          max_tokens: 1000,
          temperature: 0.7,
          stream: false
        })
      });

      if (!response.ok) {
        throw new AIServiceError(
          'DeepSeek服务请求失败',
          AI_ERRORS.SERVER_ERROR,
          response.status
        );
      }

      const data = await response.json();
      return {
        success: true,
        data: {
          reply: data.choices[0].message.content,
          timestamp: new Date().toISOString(),
          messageId: data.id || Date.now().toString()
        }
      };
    } catch (error) {
      throw this.handleError(error);
    }
  }

  handleError(error) {
    if (error instanceof AIServiceError) {
      return error;
    }

    if (error.name === 'TypeError' || error.message.includes('fetch')) {
      return new AIServiceError('网络连接失败', AI_ERRORS.NETWORK_ERROR, 0);
    }

    return new AIServiceError('未知错误', AI_ERRORS.UNKNOWN_ERROR, 0);
  }
}

// 通义千问 AI 服务
class QwenAIService {
  constructor() {
    this.config = AI_CONFIG.QWEN;
  }

  async sendMessage(message) {
    try {
      const response = await fetch(this.config.baseURL, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.config.apiKey}`
        },
        body: JSON.stringify({
          model: this.config.model,
          input: {
            messages: [
              {
                role: "system",
                content: "你是一个校园AI助手，帮助学生解决学习和生活问题。"
              },
              {
                role: "user",
                content: message
              }
            ]
          },
          parameters: {
            max_tokens: 1000,
            temperature: 0.7
          }
        })
      });

      if (!response.ok) {
        throw new AIServiceError(
          '通义千问服务请求失败',
          AI_ERRORS.SERVER_ERROR,
          response.status
        );
      }

      const data = await response.json();
      return {
        success: true,
        data: {
          reply: data.output.text,
          timestamp: new Date().toISOString(),
          messageId: data.request_id || Date.now().toString()
        }
      };
    } catch (error) {
      throw this.handleError(error);
    }
  }

  handleError(error) {
    if (error instanceof AIServiceError) {
      return error;
    }

    if (error.name === 'TypeError' || error.message.includes('fetch')) {
      return new AIServiceError('网络连接失败', AI_ERRORS.NETWORK_ERROR, 0);
    }

    return new AIServiceError('未知错误', AI_ERRORS.UNKNOWN_ERROR, 0);
  }
}

// 讯飞星火 AI 服务
class XunfeiAIService {
  constructor() {
    this.config = AI_CONFIG.XUNFEI;
  }

  async sendMessage(message) {
    try {
      // 这里需要实现讯飞星火 API 的具体调用
      // 由于需要复杂的认证过程，这里提供基本框架
      const response = await fetch(this.config.baseURL, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${this.config.apiKey}`
        },
        body: JSON.stringify({
          message: message,
          // 其他参数...
        })
      });

      if (!response.ok) {
        throw new AIServiceError(
          '讯飞星火服务请求失败',
          AI_ERRORS.SERVER_ERROR,
          response.status
        );
      }

      const data = await response.json();
      return {
        success: true,
        data: {
          reply: data.content,
          timestamp: new Date().toISOString(),
          messageId: data.id || Date.now().toString()
        }
      };
    } catch (error) {
      throw this.handleError(error);
    }
  }

  handleError(error) {
    if (error instanceof AIServiceError) {
      return error;
    }

    if (error.name === 'TypeError' || error.message.includes('fetch')) {
      return new AIServiceError('网络连接失败', AI_ERRORS.NETWORK_ERROR, 0);
    }

    return new AIServiceError('未知错误', AI_ERRORS.UNKNOWN_ERROR, 0);
  }
}

// 百度文心一言 AI 服务
class BaiduAIService {
  constructor() {
    this.config = AI_CONFIG.BAIDU;
    this.accessToken = null;
  }

  async getAccessToken() {
    try {
      const response = await fetch(
        `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${this.config.apiKey}&client_secret=${this.config.secretKey}`,
        { method: 'POST' }
      );

      const data = await response.json();
      this.accessToken = data.access_token;
      return this.accessToken;
    } catch (error) {
      throw new AIServiceError('获取访问令牌失败', AI_ERRORS.API_KEY_INVALID, 401);
    }
  }

  async sendMessage(message) {
    try {
      if (!this.accessToken) {
        await this.getAccessToken();
      }

      const response = await fetch(`${this.config.baseURL}?access_token=${this.accessToken}`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          messages: [
            {
              role: 'user',
              content: message
            }
          ]
        })
      });

      if (!response.ok) {
        throw new AIServiceError(
          '百度文心一言服务请求失败',
          AI_ERRORS.SERVER_ERROR,
          response.status
        );
      }

      const data = await response.json();
      return {
        success: true,
        data: {
          reply: data.result,
          timestamp: new Date().toISOString(),
          messageId: data.id || Date.now().toString()
        }
      };
    } catch (error) {
      throw this.handleError(error);
    }
  }

  handleError(error) {
    if (error instanceof AIServiceError) {
      return error;
    }

    if (error.name === 'TypeError' || error.message.includes('fetch')) {
      return new AIServiceError('网络连接失败', AI_ERRORS.NETWORK_ERROR, 0);
    }

    return new AIServiceError('未知错误', AI_ERRORS.UNKNOWN_ERROR, 0);
  }
}

// 主要的 AI 服务类
class AIService {
  constructor() {
    this.retryCount = 3;
    this.retryDelay = 1000;
    this.initializeService();
  }

  initializeService() {
    // 按优先级选择可用的AI服务
    if (AI_CONFIG.DEEPSEEK.enabled && AI_CONFIG.DEEPSEEK.apiKey) {
      this.service = new DeepSeekAIService();
      this.serviceName = 'DEEPSEEK';
    } else if (AI_CONFIG.QWEN.enabled && AI_CONFIG.QWEN.apiKey) {
      this.service = new QwenAIService();
      this.serviceName = 'QWEN';
    } else if (AI_CONFIG.XUNFEI.enabled && AI_CONFIG.XUNFEI.apiKey) {
      this.service = new XunfeiAIService();
      this.serviceName = 'XUNFEI';
    } else if (AI_CONFIG.BAIDU.enabled && AI_CONFIG.BAIDU.apiKey) {
      this.service = new BaiduAIService();
      this.serviceName = 'BAIDU';
    } else {
      this.service = new SmartMockAIService();
      this.serviceName = 'SMART_MOCK';
    }

    console.log(`🤖 AI Service initialized with: ${this.serviceName}`);
    if (this.serviceName === 'SMART_MOCK') {
      console.log('💡 Using enhanced mock mode. To enable real AI, configure API keys in .env file');
    }
  }

  async sendMessage(message, retryCount = 0) {
    try {
      const result = await this.service.sendMessage(message);
      return result;
    } catch (error) {
      console.error('AI Service Error:', error);

      // 重试逻辑
      if (retryCount < this.retryCount && this.shouldRetry(error)) {
        console.log(`Retrying AI request... (${retryCount + 1}/${this.retryCount})`);
        await new Promise(resolve => setTimeout(resolve, this.retryDelay * (retryCount + 1)));
        return this.sendMessage(message, retryCount + 1);
      }

      // 如果是 API 服务失败，回退到智能模拟服务
      if (this.serviceName !== 'SMART_MOCK' && this.shouldFallbackToMock(error)) {
        console.log('🔄 Falling back to smart mock service...');
        this.service = new SmartMockAIService();
        this.serviceName = 'SMART_MOCK';
        return this.sendMessage(message, 0);
      }

      throw error;
    }
  }

  shouldRetry(error) {
    // 网络错误和服务器错误可以重试
    return error.type === AI_ERRORS.NETWORK_ERROR ||
      error.type === AI_ERRORS.SERVER_ERROR ||
      error.type === AI_ERRORS.RATE_LIMIT;
  }

  shouldFallbackToMock(error) {
    // API key 无效或服务不可用时回退到模拟服务
    return error.type === AI_ERRORS.API_KEY_INVALID ||
      error.type === AI_ERRORS.SERVER_ERROR;
  }

  // 获取服务状态
  getServiceStatus() {
    const serviceInfo = {
      'DEEPSEEK': { name: 'DeepSeek AI', production: true, description: '强大的推理能力，价格优惠' },
      'QWEN': { name: '通义千问', production: true, description: '阿里云AI服务，中文优化' },
      'XUNFEI': { name: '讯飞星火', production: true, description: '中文AI助手，语音交互' },
      'BAIDU': { name: '百度文心一言', production: true, description: '百度AI大模型' },
      'SMART_MOCK': { name: '智能模拟模式', production: false, description: '增强版本地AI，无需API' }
    };

    const current = serviceInfo[this.serviceName] || serviceInfo['SMART_MOCK'];

    return {
      serviceName: this.serviceName,
      serviceDisplayName: current.name,
      serviceDescription: current.description,
      isProductionReady: current.production,
      config: {
        retryCount: this.retryCount,
        retryDelay: this.retryDelay
      },
      availableServices: Object.keys(serviceInfo).map(key => ({
        key,
        ...serviceInfo[key],
        enabled: AI_CONFIG[key]?.enabled || key === 'SMART_MOCK'
      }))
    };
  }
}

// 导出服务实例
export const aiService = new AIService();
export { AIServiceError, AI_ERRORS }; 